home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / edit / jwpsrc.zip / FILEIO.C < prev    next >
C/C++ Source or Header  |  1993-03-31  |  51KB  |  1,737 lines
  1. /* Copyright (C) Stephen Chung, 1991-1993.  All rights reserved. */
  2.  
  3. #include "jwp.h"
  4.  
  5. #include "idm.h"
  6.  
  7.  
  8. #define HIGH_BIT_ESCAPE     0
  9.  
  10. #define MAXUNDOLEVELS       32000
  11.  
  12.  
  13. static struct {
  14.     char *name;
  15. } SupportedVersions[] = {
  16.     { "B1" },
  17.     { NULL }
  18. };
  19.  
  20. static char filename[MAXFILENAMELEN];
  21. static char filespec[MAXFILENAMELEN];
  22. static OFSTRUCT of;
  23. static FILE *Fp;
  24. static FILEOPTIONS *filep;
  25. static int FormatChoice;
  26. static BOOL ConvertLineBreaks, AlignKanjis, OutputLineBreaks;
  27. static int LineLength;
  28. static long int FileLength, StatusSteps, CharRead;
  29. static HWND statushwnd, statushwnd1;
  30.  
  31. static FILEFORMAT OriginalFormat;
  32. static char *OverwriteMessage;
  33.  
  34. static BOOL HasText, InWord;
  35. static int LineNumber;
  36. static int BlankSpaces, CharPosition;
  37. static int LastIndent, CurrentIndent, FirstIndent;
  38. static int LastChar;
  39. static BOOL LastTextIsKanji;
  40. static BOOL SkipHighBitWarnings;
  41. static int LevelsSaved = 0;
  42.  
  43. static POSITION p;
  44.  
  45.  
  46. char *FileExtensions[] = {
  47.     ".*",
  48.     ".JWP",
  49.     ".TPL",
  50.     ".EUC",
  51.     ".SJS",
  52.     ".JIS",
  53.     ".OLD",
  54.     ".NEC",
  55.     NULL
  56. };
  57.  
  58. char *FileFormatNames[] = {
  59.     "Auto-Detect",
  60.     "Normal",
  61.     "Template",
  62.     "EUC",
  63.     "Shift JIS",
  64.     "New JIS",
  65.     "Old JIS",
  66.     "NEC JIS",
  67.     NULL
  68. };
  69.  
  70. BOOL FAR PASCAL FileOpenDlgProc (HWND, WORD, WORD, LONG);
  71. BOOL FAR PASCAL FileSaveAsDlgProc (HWND, WORD, WORD, LONG);
  72. extern BOOL FAR PASCAL FileFindProc (HWND, WORD, WORD, LONG);
  73.  
  74.  
  75.  
  76. static void MoveStatusBar (long int percent)
  77. {
  78.     long int len;
  79.     char     buffer[10];
  80.     HWND     hwnd;
  81.     RECT     rect;
  82.     HDC      hdc;
  83.  
  84.     if (statushwnd == NULL) return;
  85.  
  86.     if (percent < 0L) return;
  87.     if (percent > 100L) percent = 100L;
  88.  
  89.     sprintf(buffer, "%ld%%", percent);
  90.     SetDlgItemText(statushwnd, 4204, buffer);
  91.  
  92.     hwnd = GetDlgItem(statushwnd, 4205);
  93.     GetClientRect(hwnd, &rect);
  94.     len = (rect.right - 4) * percent / 100L;
  95.  
  96.     hdc = GetDC(hwnd);
  97.     SelectObject(hdc, GetStockObject(GRAY_BRUSH));
  98.     Rectangle(hdc, 2, 2, len + 2, rect.bottom - 2);
  99.     ReleaseDC(hwnd, hdc);
  100. }
  101.  
  102.  
  103.  
  104. void NewParagraph (FILEOPTIONS *f, POSITION *pos, unsigned int n)
  105. {
  106.     POSITION p = *pos;
  107.     PARAGRAPH far *pp;
  108.     ONELINE far *lp;
  109.  
  110.  
  111.     if (PARAOF(p) == NULL) {
  112.         PARAOF(p) = f->paragraph = f->eof = pp = StructAlloc(PARAGRAPH);
  113.         pp->prev = pp->next = NULL;
  114.     } else {
  115.         PARAOF(p)->next = f->eof = pp = StructAlloc(PARAGRAPH);
  116.         pp->prev = PARAOF(p);
  117.         pp->next = NULL;
  118.         PARAOF(p) = pp;
  119.     }
  120.  
  121.     pp->leftindent = pp->firstindent = pp->rightindent = 0;
  122.  
  123.     if (pp->prev != NULL) {
  124.         pp->spacing = pp->prev->spacing;
  125.         pp->spacemulti = pp->prev->spacemulti;
  126.     } else {
  127.         pp->spacing = f->basefont->spacing;
  128.         pp->spacemulti = 100;
  129.     }
  130.     n *= TEXTBLOCKSIZE;
  131.     pp->text = (UNIT far *) BlockAlloc(n * sizeof(UNIT));
  132.     pp->textsize = n;
  133.     pp->text[0].kanji = '\0';
  134.  
  135.     LINEOF(p) = lp = pp->lines = pp->lastline = StructAlloc(ONELINE);
  136.     lp->next = lp->prev = NULL;
  137.     lp->position = 0;
  138.     lp->height = BASEFONT->height;
  139.     POSOF(p) = lp->length = 0;
  140.  
  141.     f->nr_lines++;
  142.  
  143.     LineNumber = 0;
  144.     *pos = p;
  145. }
  146.  
  147.  
  148.  
  149. static void WriteNormalFile (FILE *fp, FILEOPTIONS *f, int saveundo)
  150. {
  151.     int i, j, k;
  152.     UNIT far *cp;
  153.     PARAGRAPH far *pp;
  154.     FILEHEADER header;
  155.     FILEPARAHEADER pheader;
  156.     UNDOBUF far *up;
  157.  
  158.     memset(&header, 0, sizeof(FILEHEADER));
  159.     memset(&pheader, 0, sizeof(FILEPARAHEADER));
  160.  
  161.     header.magic = MAGIC;
  162.     strcpy(header.version, JWPFILEVERSION);
  163.     header.landscape = f->pagesetup.landscape ? 1 : 0;
  164.     header.paragraphs = 0;
  165.  
  166.     header.lrheader = f->lrheader;
  167.     header.nofirstpage = f->nofirstpage;
  168.  
  169.     for (i = 0; i < 4; i++) header.margins[i] = (float) f->pagesetup.margins[i];
  170.  
  171.     for (i = 0; i < NRSUMMARIES && f->summary[i] == NULL; i++);
  172.     if (i < NRSUMMARIES) header.summary = TRUE;
  173.  
  174.     for (j = 0; j < 4; j++) {
  175.         for (i = 0; i < NRHEADERS && f->header[j][i] == NULL; i++);
  176.         if (i < NRHEADERS) {
  177.             header.headers = TRUE;
  178.             break;
  179.         }
  180.     }
  181.  
  182.  
  183.     /* Undo's */
  184.  
  185.     if (saveundo != 0) {
  186.         if (saveundo < 0) saveundo = f->undolevels;
  187.  
  188.         for (i = 0, up = f->undo; up != NULL; up = up->next, i++);
  189.         f->undolevels = i;
  190.  
  191.         if (saveundo > f->undolevels) saveundo = f->undolevels;
  192.         header.undo = saveundo;
  193.     } else {
  194.         header.undo = 0;
  195.     }
  196.  
  197.  
  198.     /* How many paragraphs? */
  199.  
  200.     for (pp = f->paragraph; pp != NULL; pp = pp->next, header.paragraphs++);
  201.  
  202.     fwrite (&header, sizeof(FILEHEADER), 1, fp);
  203.  
  204.  
  205.     /* Summaries */
  206.  
  207.     if (header.summary) {
  208.         KANJI buffer[MAXLINELEN];
  209.  
  210.         for (i = 0; i < NRSUMMARIES; i++) {
  211.             if (f->summary[i] == NULL) {
  212.                 j = 0;
  213.                 fwrite(&j, sizeof(int), 1, fp);
  214.                 continue;
  215.             }
  216.  
  217.             j = kanjilen(f->summary[i]) + 1;
  218.             if (j >= MAXLINELEN) j = MAXLINELEN - 1;
  219.             fwrite(&j, sizeof(int), 1, fp);
  220.             kanjicpy(buffer, f->summary[i]);
  221.             fwrite(buffer, sizeof(KANJI), j, fp);
  222.         }
  223.     }
  224.  
  225.     /* Headers */
  226.  
  227.     if (header.headers) {
  228.         KANJI buffer[MAXLINELEN];
  229.  
  230.         for (k = 0; k < 4; k++) {
  231.             for (i = 0; i < NRHEADERS; i++) {
  232.                 if (f->header[k][i] == NULL) {
  233.                     j = 0;
  234.                     fwrite(&j, sizeof(int), 1, fp);
  235.                     continue;
  236.                 }
  237.  
  238.                 j = kanjilen(f->header[k][i]) + 1;
  239.                 if (j >= MAXLINELEN) j = MAXLINELEN - 1;
  240.                 fwrite(&j, sizeof(int), 1, fp);
  241.                 kanjicpy(buffer, f->header[k][i]);
  242.                 fwrite(buffer, sizeof(KANJI), j, fp);
  243.             }
  244.         }
  245.     }
  246.  
  247.     /* Undo's */
  248.  
  249.     if (saveundo > 0) {
  250.         unsigned int len;
  251.         PARAGRAPH far *pp;
  252.         char buffer[MAXLINELEN];
  253.  
  254.         for (i = 0, up = f->undo; i < saveundo && up != NULL; i++, up = up->next) {
  255.             _fmemcpy(buffer, up, sizeof(UNDOBUF));
  256.             fwrite(buffer, sizeof(UNDOBUF), 1, fp);
  257.  
  258.             switch (up->action) {
  259.                 case U_INSERT: break;
  260.                 case U_DELETE:
  261.                 case U_PARAFORMAT:
  262.                     for (pp = (PARAGRAPH far *) up->data; pp != NULL; pp = pp->next) {
  263.                         _fmemcpy(buffer, pp, sizeof(PARAGRAPH));
  264.                         fwrite(buffer, sizeof(PARAGRAPH), 1, fp);
  265.                         if (pp->text == NULL) {
  266.                             len = 0;
  267.                             fwrite(&len, sizeof(int), 1, fp);
  268.                         } else {
  269.                             len = unitlen(pp->text) + 1;
  270.                             fwrite(&len, sizeof(int), 1, fp);
  271.                             _fmemcpy(buffer, pp->text, len * sizeof(UNIT));
  272.                             fwrite(buffer, sizeof(UNIT), len, fp);
  273.                         }
  274.                     }
  275.                     break;
  276.             }
  277.         }
  278.     }
  279.  
  280.     /* Output the file */
  281.  
  282.     for (CharRead = 0L, pp = f->paragraph; pp != NULL; pp = pp->next) {
  283.  
  284.         pheader.textsize = unitlen(pp->text) + 1;
  285.         pheader.spacemulti = pp->spacemulti;
  286.         pheader.firstindent = pp->firstindent;
  287.         pheader.leftindent = pp->leftindent;
  288.         pheader.rightindent = pp->rightindent;
  289.         fwrite(&pheader, sizeof(FILEPARAHEADER), 1, fp);
  290.  
  291.         for (cp = pp->text; cp->kanji; cp++, CharRead++) {
  292.             if (CharRead % StatusSteps == 0)
  293.                 MoveStatusBar(CharRead / StatusSteps);
  294.  
  295.             if (ISKANJI(cp->kanji)) {
  296.                 fputc(HIBYTE(cp->kanji) | 0x0080, fp);
  297.                 fputc(LOBYTE(cp->kanji) | 0x0080, fp);
  298.             } else if (cp->kanji & 0x0080) {
  299.                 fputc(HIGH_BIT_ESCAPE, fp);
  300.                 fputc(cp->kanji & 0x007f, fp);
  301.             } else {
  302.                 fputc(cp->kanji & 0x007f, fp);
  303.             }
  304.         }
  305.  
  306.         fputc('\n', fp);
  307.     }
  308.  
  309.     MoveStatusBar(100L);
  310. }
  311.  
  312.  
  313.  
  314. static BOOL ReadNormalFile (FILE *fp, FILEOPTIONS *f, char * filename, HWND hwnd, BOOL template)